package com.hfzy.ihk.common.core.mybatis;

/**
 * Created by Administrator on 2017/12/19.
 *
 * @author wws
 */

import org.apache.ibatis.cache.Cache;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.util.CollectionUtils;

import java.util.Set;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 *  @=====================不建议使用mabatis的二级缓存==========================
 *  * Created by Administrator on 2017/12/19.
 * @author wws
 *
 * 使用Redis来做Mybatis的二级缓存
 * 实现Mybatis的Cache接口
 * Mybatis的二级缓存可以自动地对数据库的查询做缓存，并且可以在更新数据时同时自动地更新缓存。
 实现Mybatis的二级缓存很简单，只需要新建一个类实现org.apache.ibatis.cache.Cache接口即可。

 该接口共有以下五个方法：

 String getId()：mybatis缓存操作对象的标识符。一个mapper对应一个mybatis的缓存操作对象。
 void putObject(Object key, Object value)：将查询结果塞入缓存。
 Object getObject(Object key)：从缓存中获取被缓存的查询结果。
 Object removeObject(Object key)：从缓存中删除对应的key、value。只有在回滚时触发。一般我们也可以不用实现，
    具体使用方式请参考：org.apache.ibatis.cache.decorators.TransactionalCache。
 void clear()：发生更新时，清除缓存。
 int getSize()：可选实现。返回缓存的数量。
 ReadWriteLock getReadWriteLock()：可选实现。用于实现原子性的缓存操作
 */
public class RedisCache implements Cache {

    private static final Logger logger = LoggerFactory.getLogger(RedisCache.class);

    /** 读写锁*/
    private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock(true);

    public static RedisTemplate<String, Object> redisCacheTemplate;

    private String id;

    public RedisCache(final String id) {
        if (id == null) {
            throw new IllegalArgumentException("Cache instances require an ID");
        }
        logger.info("Redis Cache id " + id);
        this.id = id;
    }

    @Override
    public String getId() {
        return this.id;
    }

    @Override
    public void putObject(Object key, Object value) {
        logger.debug("------put data into redis cache!key:{}",key);
        if (value != null) {
            // 向Redis中添加数据，有效时间是2天
            redisCacheTemplate.opsForValue().set(key.toString(), value, 2, TimeUnit.DAYS);
        }
    }

    @Override
    public Object getObject(Object key) {
        logger.debug("------get data from redis cache!key:{}",key);
        try {
            if (key != null) {
                Object obj = redisCacheTemplate.opsForValue().get(key.toString());
                return obj;
            }
        } catch (Exception e) {
            logger.error("redis ");
        }
        return null;
    }

    @Override
    public Object removeObject(Object key) {
        logger.debug("------remove data from redis cache!key:{}",key);

        try {
            if (key != null) {
                redisCacheTemplate.delete(key.toString());
            }
        } catch (Exception e) {
        }
        return null;
    }

    @Override
    public void clear() {
        logger.debug("------clear redis cache!");

        try {
            Set<String> keys = redisCacheTemplate.keys("*:" + this.id + "*");
            if (!CollectionUtils.isEmpty(keys)) {
                redisCacheTemplate.delete(keys);
            }
        } catch (Exception e) {
        }
    }

    @Override
    public int getSize() {
        logger.debug("------get  redis cache size!");
        Long size = (Long) redisCacheTemplate.execute(new RedisCallback<Long>() {
            @Override
            public Long doInRedis(RedisConnection connection) throws DataAccessException {
                return connection.dbSize();
            }
        });
        return size.intValue();
    }

    @Override
    public ReadWriteLock getReadWriteLock() {
        return this.readWriteLock;
    }

}
